{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[735, 254, 547, 342, 630, 900, 788, 827, 860, 927]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "list_or = [i for i in range(1000)]\n",
    "list_sample = random.choices(list_or,k=10)\n",
    "list_sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "输入需要查找的数字:927\n",
      "已经查询到有1个927存在于这个列表中\n",
      "程序运行次数：10\n"
     ]
    }
   ],
   "source": [
    "#顺序查找\n",
    "running_count = 0\n",
    "count = 0\n",
    "num = int(input(\"输入需要查找的数字:\"))\n",
    "for i in list_sample:\n",
    "    running_count += 1\n",
    "    if i == num:\n",
    "        count += 1\n",
    "        break\n",
    "        \n",
    "if count == 0:\n",
    "    print(f\"{num}不存在于这个列表中\")\n",
    "else:\n",
    "    print(f\"已经查询到有{count}个{num}存在于这个列表中\")\n",
    "print(f\"程序运行次数：{running_count}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "输入需要查找的数字:1000\n",
      "已经查询到有1个1000存在于这个列表中\n",
      "程序运行次数：4\n"
     ]
    }
   ],
   "source": [
    "#二分法查找\n",
    "list_sample = [735, 254, 547, 342, 630, 900, 788, 827, 860, 927,1000]\n",
    "num = int(input(\"输入需要查找的数字:\"))\n",
    "\n",
    "def find_index(list_sample,running_count = 0,count = 0):\n",
    "    list_sample.sort()\n",
    "    running_count += 1\n",
    "    if len(list_sample) == 0:\n",
    "        print(\"这是一个空列表，无须查找元素\")\n",
    "        print(f\"程序运行次数：{running_count}\")\n",
    "    elif len(list_sample) == 1:\n",
    "        if list_sample[0] == num:\n",
    "            count += 1\n",
    "            index = 0\n",
    "            print(f\"已经查询到有{count}个{num}存在于这个列表中\")\n",
    "            print(f\"程序运行次数：{running_count}\")\n",
    "        else:\n",
    "            print(f\"{num}不存在于这个列表中\")\n",
    "            print(f\"程序运行次数：{running_count}\")\n",
    "    else:\n",
    "        middle_index = len(list_sample)//2\n",
    "        middle_num = list_sample[middle_index]\n",
    "        if middle_num == num:\n",
    "            count += 1\n",
    "            print(f\"已经查询到有{count}个{num}存在于这个列表中\")\n",
    "            print(f\"程序运行次数：{running_count}\")\n",
    "        elif middle_num < num:\n",
    "            new_list = list_sample[middle_index:]\n",
    "            find_index(new_list,running_count,count)\n",
    "        elif middle_num > num:\n",
    "            new_list = list_sample[:middle_index]\n",
    "            find_index(new_list,running_count,count)\n",
    "    \n",
    "   \n",
    "find_index(list_sample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#第1次： 11 // 2 = 5\n",
    "#第2次： 5 // 2 = 2\n",
    "#第3次： 2 // 2 = 1\n",
    "#第4次： 1 // 2 = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import math\n",
    "\n",
    "plt.title(\"running times\")\n",
    "plt.xlabel(\"x = length\")\n",
    "plt.ylabel(\"y = running times\")\n",
    "\n",
    "x = np.arange(2,10,0.001)\n",
    "y1 = x\n",
    "y2 = [math.log(i,2) for i in x]\n",
    "plt.plot([1,2],[1,2],x,y1,x,y2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "#差值查找算法\n",
    "list_sample = [735, 254, 547, 342, 630, 900, 788, 827, 860, 927]\n",
    "num = int(input(\"输入需要查找的数字:\"))\n",
    "\n",
    "def find_index(num_list,running_count = 0,count = 0):\n",
    "    num_list.sort()\n",
    "    running_count += 1\n",
    "    if len(num_list) == 0:\n",
    "        print(\"这是一个空列表，无须查找元素\")\n",
    "        print(f\"程序运行次数：{running_count}\")\n",
    "    elif len(num_list) == 1:\n",
    "        if num_list[0] == num:\n",
    "            count += 1\n",
    "            print(f\"已经查询到有{count}个{num}存在于这个列表中\")\n",
    "            print(f\"程序运行次数：{running_count}\")\n",
    "        else:\n",
    "            print(f\"{num}不存在于这个列表中\")\n",
    "            print(f\"程序运行次数：{running_count}\")       \n",
    "    else:\n",
    "        if num <= num_list[-1] and num >= num_list[0]:\n",
    "            index = int((len(num_list) - 1) * (num - num_list[0]) /(num_list[-1] - num_list[0]))\n",
    "            middle_num = num_list[index]\n",
    "            if middle_num == num:\n",
    "                count += 1\n",
    "                print(f\"已经查询到有{count}个{num}存在于这个列表中\")\n",
    "                print(f\"程序运行次数：{running_count}\")\n",
    "            elif middle_num < num:\n",
    "                new_list = num_list[index+1:]\n",
    "                find_index(new_list,running_count,count)\n",
    "            elif middle_num > num:\n",
    "                new_list = num_list[:index]\n",
    "                find_index(new_list,running_count,count)\n",
    "        else:print(f\"{num}不存在于这个列表中\\n程序运行次数：{running_count}\")\n",
    "    \n",
    "   \n",
    "find_index(list_sample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Fibonacci = [0,1,1,2,3,5,8,13,21,34,...]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "输入需要查找的数字:1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[254, 342, 547, 630, 735, 788, 827, 860, 900, 927, 1000]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#斐波那契数列查找\n",
    "list_sample = [735, 254, 547, 342, 630, 900, 788, 827, 860, 927,1000]\n",
    "list_sample.sort()\n",
    "num = int(input(\"输入需要查找的数字:\"))\n",
    "list_sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "输入需要生成的斐波那契数列长度:20\n",
      "长度为20的斐波那契数列已生成:\n",
      "Fibonacci =  [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]\n"
     ]
    }
   ],
   "source": [
    "def fibonacci(length):\n",
    "    if length == 1:\n",
    "        fibonacci = [0]\n",
    "    elif length == 2:\n",
    "        fibonacci = [0,1]\n",
    "    elif length > 2:\n",
    "        fibonacci = [0,1]\n",
    "        start = 2\n",
    "        while start < length:\n",
    "            fibonacci.append(fibonacci[start-1] + fibonacci[start-2])\n",
    "            start += 1\n",
    "    else:\n",
    "        return \"数列长度必须为正数\"\n",
    "    return fibonacci\n",
    "\n",
    "length = int(input(\"输入需要生成的斐波那契数列长度:\"))\n",
    "print(f\"长度为{length}的斐波那契数列已生成:\")\n",
    "print(\"Fibonacci = \",fibonacci(length))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "输入需要生成的斐波那契数列长度:15\n",
      "长度为15的斐波那契数列已生成:\n",
      "Fibonacci =  [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]\n",
      "输入需要查找的数字:735\n",
      "已经查询到有1个735存在于这个列表中\n",
      "程序运行次数：1\n"
     ]
    }
   ],
   "source": [
    "#斐波那契数列查找\n",
    "\n",
    "def fibonacci(length):\n",
    "    if length == 1:\n",
    "        fibonacci = [0]\n",
    "    elif length == 2:\n",
    "        fibonacci = [0,1]\n",
    "    elif length > 2:\n",
    "        fibonacci = [0,1]\n",
    "        start = 2\n",
    "        while start < length:\n",
    "            fibonacci.append(fibonacci[start-1] + fibonacci[start-2])\n",
    "            start += 1\n",
    "    else:\n",
    "        return \"数列长度必须为正数\"\n",
    "    return fibonacci\n",
    "\n",
    "fibonacci = fibonacci(length)\n",
    "\n",
    "length = int(input(\"输入需要生成的斐波那契数列长度:\"))\n",
    "print(f\"长度为{length}的斐波那契数列已生成:\")\n",
    "print(\"Fibonacci = \",fibonacci)\n",
    "\n",
    "\n",
    "list_sample = [735, 254, 547, 342, 630, 900, 788, 827, 860, 927]\n",
    "num = int(input(\"输入需要查找的数字:\"))\n",
    "\n",
    "\n",
    "        \n",
    "def find_index(num_list,running_count = 0,count = 0):\n",
    "    num_list.sort()       \n",
    "    running_count += 1    \n",
    "       \n",
    "    for index,i in enumerate(fibonacci):\n",
    "        if len(num_list) <= i and len(num_list) > fibonacci[index-1]:\n",
    "            length_std = i\n",
    "            break\n",
    "\n",
    "    while len(num_list) < length_std:\n",
    "        num_list.append(num_list[-1])\n",
    "        \n",
    "    if len(num_list) == 0:\n",
    "        print(\"这是一个空列表，无须查找元素\")\n",
    "        print(f\"程序运行次数：{running_count}\")\n",
    "    elif len(num_list) == 1:\n",
    "        if num_list[0] == num:\n",
    "            count += 1\n",
    "            print(f\"已经查询到有{count}个{num}存在于这个列表中\")\n",
    "            print(f\"程序运行次数：{running_count}\")\n",
    "        else:\n",
    "            print(f\"{num}不存在于这个列表中\")\n",
    "            print(f\"程序运行次数：{running_count}\")       \n",
    "    else:\n",
    "        if num <=num_list[-1] and num >= num_list[0]:\n",
    "            index_num = fibonacci[index - 2] - 1\n",
    "            middle_num = num_list[index_num]\n",
    "            if middle_num == num:\n",
    "                count += 1\n",
    "                print(f\"已经查询到有{count}个{num}存在于这个列表中\")\n",
    "                print(f\"程序运行次数：{running_count}\")\n",
    "            elif middle_num < num:\n",
    "                new_list = num_list[index_num+1:]\n",
    "                find_index(new_list,running_count,count)\n",
    "            elif middle_num > num:\n",
    "                new_list = num_list[:index_num+1]\n",
    "                find_index(new_list,running_count,count)\n",
    "        else:print(f\"{num}不存在于这个列表中\\n程序运行次数：{running_count}\")\n",
    "    \n",
    "   \n",
    "find_index(list_sample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "plt.xlabel(\"x\",labelpad=10)\n",
    "plt.ylabel(\"y\")\n",
    "plt.title(\"Fibonacci\")\n",
    "x = np.arange(0,2.0001,0.0001)\n",
    "y = [math.sqrt(1 - pow(i-1,2)) for i in x]\n",
    "plt.plot(x,y)\n",
    "\n",
    "x = np.arange(2,0,-0.0001)\n",
    "y = [-math.sqrt(4 - pow(i,2)) for i in x]\n",
    "plt.plot(x,y)\n",
    "\n",
    "x = np.arange(0,-3,-0.0001)\n",
    "y = [1-math.sqrt(9 - pow(i,2)) for i in x]\n",
    "plt.plot(x,y)\n",
    "\n",
    "x = np.arange(-3,2,0.0001)\n",
    "y = [1+math.sqrt(25 - pow(i-2,2)) for i in x]\n",
    "plt.plot(x,y)\n",
    "\n",
    "x = np.arange(2,10,0.0001)\n",
    "y = [-2+math.sqrt(64 - pow(i-2,2)) for i in x]\n",
    "plt.plot(x,y)\n",
    "\n",
    "x = np.arange(10,-3,-0.0001)\n",
    "y = [-2-math.sqrt(169 - pow(i+3,2)) for i in x]\n",
    "plt.plot(x,y)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#二叉树"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
